#include "vector.h"
#include<assert.h>
#include<string.h>

using namespace myv;

// 构造函数
template<class T>
Vector<T>::Vector()
:_start(nullptr)
,_finish(nullptr)
,_endOfStorage(nullptr)
{}
    
// 复制构造函数
template<class T>
Vector<T>::Vector( Vector<T>& v)
:_start(nullptr)
,_finish(nullptr)
,_endOfStorage(nullptr)
{
    _start = new T[v.capacity()];
    for (size_t i = 0; i < size(); ++i)
    {
        _start[i] = v._start[i];
    }
    _finish = _start + v.size();
    _endOfStorage = _start + v.capacity();
    #ifdef DEBUG
        printf("数组长度为%zu\n", capacity());
    #endif
}

// 析构函数
template<class T>
Vector<T>::~Vector()
{
    if(_start){
        delete[] _start;
        _start = _finish = _endOfStorage = nullptr;
    }
}

// const表示只读函数，不会改变属性的值。
// 数据大小
template<class T>
size_t  Vector<T>::size() const
{
    return _finish - _start;
}

// 空间大小
template<class T>
size_t Vector<T>::capacity() const{
    return _endOfStorage - _start;
}

// 扩容
template<class T>
void Vector<T>::expand(size_t n)
{
    #ifdef DEBUG
        printf("调用expand函数\n");
    #endif
   if (n > capacity())
    {
        size_t num = size();
        T* arr = new T[n];
        if (_start)
        {
            memcpy(arr, _start, sizeof(T) * num);
            delete[] _start;
         }
        _start = arr;
        _finish = _start + num;
        _endOfStorage = _start + n;
    }
}

// 插入元素
template<class T>
void Vector<T>::push_back(const T& t){
    if (_finish == _endOfStorage)
    {
        size_t n = _endOfStorage == nullptr ? 1 : 2 * capacity();
        expand(n);
    }
    *_finish = t;	
    ++_finish;
    #ifdef DEBUG
        printf("数据数量为%zu\n", size());
    #endif
}

// 弹出元素
template<class T>
void Vector<T>::pop_back(){
    assert(size() > 0);
    --_finish;
    #ifdef DEBUG
        printf("数据数量为%zu\n", size());
    #endif
}

// 查找元素
template<class T>
T Vector<T>::at(size_t pos){
       #ifdef DEBUG
            assert(pos < size());
            printf("调用at函数\n");
        #endif
       return _start[pos];
}

// 操作符[]重载，访问vector元素
template<class T>
T& Vector<T>::operator[](size_t pos)
{
    #ifdef DEBUG
        assert(pos < size());
        printf("重写[]操作符\n");
    #endif
   return _start[pos];
}

// 清空元素
template<class T>
void Vector<T>::clear(){
    #ifdef DEBUG
        printf("调用clear函数\n");
    #endif
    _finish = _endOfStorage = _start;
}